package com.wandian.executor;

import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * 定时器执行命令线程池
 * 
 * @author long
 * @Create 2012-10-10 下午12:05:09
 * @QQ 108232706
 * @version 1.0
 * @description TimerMgr
 */
public class TimerMgr {
	private static ScheduledExecutorService service;

	private static boolean isInit = false;
	// corePoolSize the number of threads
	private static int corePoolSize;
	private static int timerIndex = 0;

	public synchronized static int getTimerIndex() {
		return timerIndex++;
	}

	public synchronized static boolean init(int _corePoolSize) {
		if (!isInit) {
			corePoolSize = _corePoolSize;
			service = Executors.newScheduledThreadPool(corePoolSize, new SimpleThreadFactory("TimerMgrService", false));
			isInit = true;
		}
		return true;
	}

	/**
	 * 将一个指定push进时间线程池，并在延时后执行一次
	 * 
	 * @param command
	 * @param delay
	 */
	public static ScheduledFuture<?> push(Runnable command, long delay) {
		// MILLISECONDS 毫秒 1000=1秒；MICROSECONDS 微秒 10^6=1秒,NANOSECONDS 纳秒 10^9
		// ，MINUTES,HOURS,DAYS
//		command.run();
		return service.schedule(command, delay, TimeUnit.SECONDS);
	}

	/**
	 * 将一个指定push进时间线程池，并在延时后执行一次
	 * 
	 * @param command
	 * @param delay
	 * @param unit
	 * @return
	 */
	public static ScheduledFuture<?> push(Runnable command, long delay, TimeUnit unit) {
		// MILLISECONDS 毫秒 1000=1秒；MICROSECONDS 微秒 10^6=1秒,NANOSECONDS 纳秒 10^9
		// ，MINUTES,HOURS,DAYS
		return service.schedule(command, delay, unit);
	}

	/**
	 * 
	 * @param command
	 * @param delay
	 */
	/**
	 * 将一个指定push进时间线程池，并在延时delay+intervale后执行一次,delay+intervale*n执行n次
	 * 
	 * @param command
	 * @param delay
	 * @param intervale
	 */
	public static ScheduledFuture<?> push(Runnable command, long delay, long intervale) {
		return service.scheduleAtFixedRate(command, delay, intervale, TimeUnit.SECONDS);
	}

	/**
	 * 一个指定push进时间线程池，并在延时delay+intervale后执行一次,delay+intervale*n执行n次
	 * 
	 * @param command
	 * @param delay
	 * @param intervale
	 * @param unit
	 * @return
	 */
	public static ScheduledFuture<?> push(Runnable command, long delay, long intervale, TimeUnit unit) {
		return service.scheduleAtFixedRate(command, delay, intervale, unit);
	}

	/**
	 * 关闭定时器线程池，停止正在进行的，并返回在队列中为执行的命令
	 * 
	 * @return
	 */
	public static List<Runnable> shutdownNow() {
		return service.shutdownNow();
	}

	/**
	 * 发起一个有序的关闭，在以前已提交      *任务的执行，但不接受新任务。      *调用没有额外的效果，如果已经关闭。
	 * 
	 * @return
	 */
	public static void shutdown() {
		service.shutdown();
	}

	/**
	 * 在指定的秒内，停止定时器任务
	 * 
	 * @param delay
	 */
	public static void shutdown(long delay) {
		push(new Runnable() {
			public void run() {
				TimerMgr.shutdown();
			}
		}, delay);
	}

	/**
	 * 在指定的时间单位内，停止定时器任务
	 * 
	 * @param delay
	 * @param unit
	 */
	public static void shutdown(long delay, TimeUnit unit) {
		push(new Runnable() {
			public void run() {
				TimerMgr.shutdown();
			}
		}, delay, unit);
	}

	/**
	 * 在超时之前，阻塞等待命令执行完
	 * 
	 * @param timeout
	 * @throws InterruptedException
	 */
	public static void awaitTermination(long timeout) throws InterruptedException {
		service.awaitTermination(timeout, TimeUnit.SECONDS);
	}

	/**
	 * 在指定的时间内，取消某个任务
	 * 
	 * @param commaFuture
	 * @param delay
	 */
	public static void Cancel(final ScheduledFuture<?> commaFuture, long delay) {
		Cancel(commaFuture, delay, TimeUnit.SECONDS);
	}

	/**
	 * 在指定的时间内，取消某个任务
	 * 
	 * @param commaFuture
	 * @param delay
	 * @param unit
	 */
	public static void Cancel(final ScheduledFuture<?> commaFuture, long delay, TimeUnit unit) {
		service.schedule(new Runnable() {
			public void run() {
				commaFuture.cancel(true);
			}
		}, delay, unit);
	}
}
